package com.huangyi.portalservice.city.service.impl;


import com.huangyi.adminapi.map.domain.vo.RegionVO;
import com.huangyi.adminapi.map.feign.MapFeignClient;
import com.huangyi.commoncore.utils.BeanCopyUtil;
import com.huangyi.commondomain.domain.R;
import com.huangyi.commondomain.domain.ResultCode;
import com.huangyi.portalservice.city.domain.vo.CityPageVO;
import com.huangyi.portalservice.city.service.ICityService;
import com.huangyi.portalservice.homepage.domain.vo.CityDescVO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;

@Service
@Slf4j
public class CityServiceImpl implements ICityService {

    @Autowired
    private Executor threadPoolTaskExecutor;
    @Autowired
    private MapFeignClient mapFeignClient;

    /**
     * 查询热门城市与全城市列表
     */
    @Override
    public CityPageVO getCityPage() {
        // 异步编排
        // 查询热门城市列表
        // 查询全城市map(a-z)
        CompletableFuture<List<CityDescVO>> hotCityListFuture =  CompletableFuture.supplyAsync(
                this::getHotCityList, threadPoolTaskExecutor);
        CompletableFuture<Map<String, List<CityDescVO>>> cityPyMapFuture =  CompletableFuture.supplyAsync(
                this::getCityPyMap, threadPoolTaskExecutor);

        // 等待异步任务全部完成
        CompletableFuture<Void> completableFuture =
                CompletableFuture.allOf(hotCityListFuture, cityPyMapFuture);
        try {
            completableFuture.get(); // 等待所有异步操作完成
        } catch (Exception e) {
            log.error("异步并发调用出现异常", e);
        }

        // 构造返回
        List<CityDescVO> hotCityList = hotCityListFuture.join();
        Map<String, List<CityDescVO>> cityPyMap = cityPyMapFuture.join();
        CityPageVO cityPageVO = new CityPageVO();
        cityPageVO.setHotCityList(hotCityList);
        cityPageVO.setAllCityMap(cityPyMap);
        return cityPageVO;

    }

    /**
     * 获取全城市映射（a-z）
     *
     * @return 城市拼音映射（key = 拼音首字母，value = 城市信息列表），失败时返回空 Map
     */
    private Map<String, List<CityDescVO>> getCityPyMap() {
        // 调用地图服务接口，获取拼音分类城市列表
        R<Map<String, List<RegionVO>>> mapR = mapFeignClient.getCityPyList();

        // 判空 + 校验返回码，失败则打日志并返回空 Map，避免返回 null
        if(mapR == null || mapR.getCode() != ResultCode.SUCCESS.getCode() || mapR.getData() == null ) {
            log.error("获取拼音分类城市列表失败!");
            return new HashMap<>();
        }

        // 拿到接口返回的原始数据（RegionVO 按拼音首字母分组）
        Map<String, List<RegionVO>> tmpMap = mapR.getData();
        // 新建目标结果 Map（key=拼音首字母，value=CityDescVO 列表）
        Map<String, List<CityDescVO>> cityPyMap = new HashMap<>();

        // 遍历原始 Map，将 RegionVO 转换为 CityDescVO
        for(Map.Entry<String, List<RegionVO>> entry : tmpMap.entrySet()) {
            List<RegionVO> regionVOS = entry.getValue();
            // BeanCopy 工具批量转换对象类型
            List<CityDescVO> cityPyList = BeanCopyUtil.copyListProperties(regionVOS, CityDescVO::new);
            // 放入结果 Map
            cityPyMap.put(entry.getKey(), cityPyList);
        }

        // 返回最终构造好的 Map
        return cityPyMap;
    }

    /**
     * 获取热门城市列表
     *
     * @return 热门城市列表，失败时返回空 List
     */
    private List<CityDescVO> getHotCityList() {
        // 调用地图服务接口，获取热门城市列表
        R<List<RegionVO>> listR =  mapFeignClient.getCityHostList();

        // 判空 + 校验返回码，失败则打日志并返回空 List，避免返回 null
        if(listR == null || listR.getData() == null || listR.getCode() != ResultCode.SUCCESS.getCode()){
            log.error("获取热门城市列表失败!");
            return new ArrayList<>();
        }

        // 拿到接口返回的原始数据（RegionVO 列表）
        List<RegionVO> regionList = listR.getData();
        // BeanCopy 工具批量转换为 CityDescVO
        List<CityDescVO> cityHostList = BeanCopyUtil.copyListProperties(regionList, CityDescVO::new);

        // 返回最终构造好的热门城市列表
        return cityHostList;
    }
}